home *** CD-ROM | disk | FTP | other *** search
/ PCGUIA 127 / PC Guia 127.iso / Software / Produtividade / OpenOffice.org 2.0.1 / openofficeorg4.cab / test_array.py < prev    next >
Text File  |  2005-11-19  |  29KB  |  878 lines
  1. #! /usr/bin/env python
  2. """Test the arraymodule.
  3.    Roger E. Masse
  4. """
  5.  
  6. import unittest
  7. from test import test_support
  8. import array, cStringIO, math
  9.  
  10. tests = [] # list to accumulate all tests
  11. typecodes = "cubBhHiIlLfd"
  12.  
  13. class BadConstructorTest(unittest.TestCase):
  14.  
  15.     def test_constructor(self):
  16.         self.assertRaises(TypeError, array.array)
  17.         self.assertRaises(TypeError, array.array, spam=42)
  18.         self.assertRaises(TypeError, array.array, 'xx')
  19.         self.assertRaises(ValueError, array.array, 'x')
  20.  
  21. tests.append(BadConstructorTest)
  22.  
  23. class BaseTest(unittest.TestCase):
  24.     # Required class attributes (provided by subclasses
  25.     # typecode: the typecode to test
  26.     # example: an initializer usable in the constructor for this type
  27.     # smallerexample: the same length as example, but smaller
  28.     # biggerexample: the same length as example, but bigger
  29.     # outside: An entry that is not in example
  30.     # minitemsize: the minimum guaranteed itemsize
  31.  
  32.     def assertEntryEqual(self, entry1, entry2):
  33.         self.assertEqual(entry1, entry2)
  34.  
  35.     def badtypecode(self):
  36.         # Return a typecode that is different from our own
  37.         return typecodes[(typecodes.index(self.typecode)+1) % len(typecodes)]
  38.  
  39.     def test_constructor(self):
  40.         a = array.array(self.typecode)
  41.         self.assertEqual(a.typecode, self.typecode)
  42.         self.assert_(a.itemsize>=self.minitemsize)
  43.         self.assertRaises(TypeError, array.array, self.typecode, None)
  44.  
  45.     def test_len(self):
  46.         a = array.array(self.typecode)
  47.         a.append(self.example[0])
  48.         self.assertEqual(len(a), 1)
  49.  
  50.         a = array.array(self.typecode, self.example)
  51.         self.assertEqual(len(a), len(self.example))
  52.  
  53.     def test_buffer_info(self):
  54.         a = array.array(self.typecode, self.example)
  55.         self.assertRaises(TypeError, a.buffer_info, 42)
  56.         bi = a.buffer_info()
  57.         self.assert_(isinstance(bi, tuple))
  58.         self.assertEqual(len(bi), 2)
  59.         self.assert_(isinstance(bi[0], int))
  60.         self.assert_(isinstance(bi[1], int))
  61.         self.assertEqual(bi[1], len(a))
  62.  
  63.     def test_byteswap(self):
  64.         a = array.array(self.typecode, self.example)
  65.         self.assertRaises(TypeError, a.byteswap, 42)
  66.         if a.itemsize in (1, 2, 4, 8):
  67.             b = array.array(self.typecode, self.example)
  68.             b.byteswap()
  69.             if a.itemsize==1:
  70.                 self.assertEqual(a, b)
  71.             else:
  72.                 self.assertNotEqual(a, b)
  73.             b.byteswap()
  74.             self.assertEqual(a, b)
  75.  
  76.     def test_insert(self):
  77.         a = array.array(self.typecode, self.example)
  78.         a.insert(0, self.example[0])
  79.         self.assertEqual(len(a), 1+len(self.example))
  80.         self.assertEqual(a[0], a[1])
  81.         self.assertRaises(TypeError, a.insert)
  82.         self.assertRaises(TypeError, a.insert, None)
  83.         self.assertRaises(TypeError, a.insert, 0, None)
  84.  
  85.         a = array.array(self.typecode, self.example)
  86.         a.insert(-1, self.example[0])
  87.         self.assertEqual(
  88.             a,
  89.             array.array(
  90.                 self.typecode,
  91.                 self.example[:-1] + self.example[:1] + self.example[-1:]
  92.             )
  93.         )
  94.  
  95.         a = array.array(self.typecode, self.example)
  96.         a.insert(-1000, self.example[0])
  97.         self.assertEqual(
  98.             a,
  99.             array.array(self.typecode, self.example[:1] + self.example)
  100.         )
  101.  
  102.         a = array.array(self.typecode, self.example)
  103.         a.insert(1000, self.example[0])
  104.         self.assertEqual(
  105.             a,
  106.             array.array(self.typecode, self.example + self.example[:1])
  107.         )
  108.  
  109.     def test_tofromfile(self):
  110.         a = array.array(self.typecode, 2*self.example)
  111.         self.assertRaises(TypeError, a.tofile)
  112.         self.assertRaises(TypeError, a.tofile, cStringIO.StringIO())
  113.         f = open(test_support.TESTFN, 'wb')
  114.         try:
  115.             a.tofile(f)
  116.             f.close()
  117.             b = array.array(self.typecode)
  118.             f = open(test_support.TESTFN, 'rb')
  119.             self.assertRaises(TypeError, b.fromfile)
  120.             self.assertRaises(
  121.                 TypeError,
  122.                 b.fromfile,
  123.                 cStringIO.StringIO(), len(self.example)
  124.             )
  125.             b.fromfile(f, len(self.example))
  126.             self.assertEqual(b, array.array(self.typecode, self.example))
  127.             self.assertNotEqual(a, b)
  128.             b.fromfile(f, len(self.example))
  129.             self.assertEqual(a, b)
  130.             self.assertRaises(EOFError, b.fromfile, f, 1)
  131.             f.close()
  132.         finally:
  133.             if not f.closed:
  134.                 f.close()
  135.             test_support.unlink(test_support.TESTFN)
  136.  
  137.     def test_tofromlist(self):
  138.         a = array.array(self.typecode, 2*self.example)
  139.         b = array.array(self.typecode)
  140.         self.assertRaises(TypeError, a.tolist, 42)
  141.         self.assertRaises(TypeError, b.fromlist)
  142.         self.assertRaises(TypeError, b.fromlist, 42)
  143.         self.assertRaises(TypeError, b.fromlist, [None])
  144.         b.fromlist(a.tolist())
  145.         self.assertEqual(a, b)
  146.  
  147.     def test_tofromstring(self):
  148.         a = array.array(self.typecode, 2*self.example)
  149.         b = array.array(self.typecode)
  150.         self.assertRaises(TypeError, a.tostring, 42)
  151.         self.assertRaises(TypeError, b.fromstring)
  152.         self.assertRaises(TypeError, b.fromstring, 42)
  153.         b.fromstring(a.tostring())
  154.         self.assertEqual(a, b)
  155.         if a.itemsize>1:
  156.             self.assertRaises(ValueError, b.fromstring, "x")
  157.  
  158.     def test_repr(self):
  159.         a = array.array(self.typecode, 2*self.example)
  160.         self.assertEqual(a, eval(repr(a), {"array": array.array}))
  161.  
  162.         a = array.array(self.typecode)
  163.         self.assertEqual(repr(a), "array('%s')" % self.typecode)
  164.  
  165.     def test_str(self):
  166.         a = array.array(self.typecode, 2*self.example)
  167.         str(a)
  168.  
  169.     def test_cmp(self):
  170.         a = array.array(self.typecode, self.example)
  171.         self.assert_((a == 42) is False)
  172.         self.assert_((a != 42) is True)
  173.  
  174.         self.assert_((a == a) is True)
  175.         self.assert_((a != a) is False)
  176.         self.assert_((a < a) is False)
  177.         self.assert_((a <= a) is True)
  178.         self.assert_((a > a) is False)
  179.         self.assert_((a >= a) is True)
  180.  
  181.         as = array.array(self.typecode, self.smallerexample)
  182.         ab = array.array(self.typecode, self.biggerexample)
  183.  
  184.         self.assert_((a == 2*a) is False)
  185.         self.assert_((a != 2*a) is True)
  186.         self.assert_((a < 2*a) is True)
  187.         self.assert_((a <= 2*a) is True)
  188.         self.assert_((a > 2*a) is False)
  189.         self.assert_((a >= 2*a) is False)
  190.  
  191.         self.assert_((a == as) is False)
  192.         self.assert_((a != as) is True)
  193.         self.assert_((a < as) is False)
  194.         self.assert_((a <= as) is False)
  195.         self.assert_((a > as) is True)
  196.         self.assert_((a >= as) is True)
  197.  
  198.         self.assert_((a == ab) is False)
  199.         self.assert_((a != ab) is True)
  200.         self.assert_((a < ab) is True)
  201.         self.assert_((a <= ab) is True)
  202.         self.assert_((a > ab) is False)
  203.         self.assert_((a >= ab) is False)
  204.  
  205.     def test_add(self):
  206.         a = array.array(self.typecode, self.example) \
  207.             + array.array(self.typecode, self.example[::-1])
  208.         self.assertEqual(
  209.             a,
  210.             array.array(self.typecode, self.example + self.example[::-1])
  211.         )
  212.  
  213.         b = array.array(self.badtypecode())
  214.         self.assertRaises(TypeError, a.__add__, b)
  215.  
  216.         self.assertRaises(TypeError, a.__add__, "bad")
  217.  
  218.     def test_iadd(self):
  219.         a = array.array(self.typecode, self.example[::-1])
  220.         b = a
  221.         a += array.array(self.typecode, 2*self.example)
  222.         self.assert_(a is b)
  223.         self.assertEqual(
  224.             a,
  225.             array.array(self.typecode, self.example[::-1]+2*self.example)
  226.         )
  227.  
  228.         b = array.array(self.badtypecode())
  229.         self.assertRaises(TypeError, a.__add__, b)
  230.  
  231.         self.assertRaises(TypeError, a.__iadd__, "bad")
  232.  
  233.     def test_mul(self):
  234.         a = 5*array.array(self.typecode, self.example)
  235.         self.assertEqual(
  236.             a,
  237.             array.array(self.typecode, 5*self.example)
  238.         )
  239.  
  240.         a = array.array(self.typecode, self.example)*5
  241.         self.assertEqual(
  242.             a,
  243.             array.array(self.typecode, self.example*5)
  244.         )
  245.  
  246.         a = 0*array.array(self.typecode, self.example)
  247.         self.assertEqual(
  248.             a,
  249.             array.array(self.typecode)
  250.         )
  251.  
  252.         a = (-1)*array.array(self.typecode, self.example)
  253.         self.assertEqual(
  254.             a,
  255.             array.array(self.typecode)
  256.         )
  257.  
  258.         self.assertRaises(TypeError, a.__mul__, "bad")
  259.  
  260.     def test_imul(self):
  261.         a = array.array(self.typecode, self.example)
  262.         b = a
  263.  
  264.         a *= 5
  265.         self.assert_(a is b)
  266.         self.assertEqual(
  267.             a,
  268.             array.array(self.typecode, 5*self.example)
  269.         )
  270.  
  271.         a *= 0
  272.         self.assert_(a is b)
  273.         self.assertEqual(a, array.array(self.typecode))
  274.  
  275.         a *= 1000
  276.         self.assert_(a is b)
  277.         self.assertEqual(a, array.array(self.typecode))
  278.  
  279.         a *= -1
  280.         self.assert_(a is b)
  281.         self.assertEqual(a, array.array(self.typecode))
  282.  
  283.         a = array.array(self.typecode, self.example)
  284.         a *= -1
  285.         self.assertEqual(a, array.array(self.typecode))
  286.  
  287.         self.assertRaises(TypeError, a.__imul__, "bad")
  288.  
  289.     def test_getitem(self):
  290.         a = array.array(self.typecode, self.example)
  291.         self.assertEntryEqual(a[0], self.example[0])
  292.         self.assertEntryEqual(a[0L], self.example[0])
  293.         self.assertEntryEqual(a[-1], self.example[-1])
  294.         self.assertEntryEqual(a[-1L], self.example[-1])
  295.         self.assertEntryEqual(a[len(self.example)-1], self.example[-1])
  296.         self.assertEntryEqual(a[-len(self.example)], self.example[0])
  297.         self.assertRaises(TypeError, a.__getitem__)
  298.         self.assertRaises(IndexError, a.__getitem__, len(self.example))
  299.         self.assertRaises(IndexError, a.__getitem__, -len(self.example)-1)
  300.  
  301.     def test_setitem(self):
  302.         a = array.array(self.typecode, self.example)
  303.         a[0] = a[-1]
  304.         self.assertEntryEqual(a[0], a[-1])
  305.  
  306.         a = array.array(self.typecode, self.example)
  307.         a[0L] = a[-1]
  308.         self.assertEntryEqual(a[0], a[-1])
  309.  
  310.         a = array.array(self.typecode, self.example)
  311.         a[-1] = a[0]
  312.         self.assertEntryEqual(a[0], a[-1])
  313.  
  314.         a = array.array(self.typecode, self.example)
  315.         a[-1L] = a[0]
  316.         self.assertEntryEqual(a[0], a[-1])
  317.  
  318.         a = array.array(self.typecode, self.example)
  319.         a[len(self.example)-1] = a[0]
  320.         self.assertEntryEqual(a[0], a[-1])
  321.  
  322.         a = array.array(self.typecode, self.example)
  323.         a[-len(self.example)] = a[-1]
  324.         self.assertEntryEqual(a[0], a[-1])
  325.  
  326.         self.assertRaises(TypeError, a.__setitem__)
  327.         self.assertRaises(TypeError, a.__setitem__, None)
  328.         self.assertRaises(TypeError, a.__setitem__, 0, None)
  329.         self.assertRaises(
  330.             IndexError,
  331.             a.__setitem__,
  332.             len(self.example), self.example[0]
  333.         )
  334.         self.assertRaises(
  335.             IndexError,
  336.             a.__setitem__,
  337.             -len(self.example)-1, self.example[0]
  338.         )
  339.  
  340.     def test_delitem(self):
  341.         a = array.array(self.typecode, self.example)
  342.         del a[0]
  343.         self.assertEqual(
  344.             a,
  345.             array.array(self.typecode, self.example[1:])
  346.         )
  347.  
  348.         a = array.array(self.typecode, self.example)
  349.         del a[-1]
  350.         self.assertEqual(
  351.             a,
  352.             array.array(self.typecode, self.example[:-1])
  353.         )
  354.  
  355.         a = array.array(self.typecode, self.example)
  356.         del a[len(self.example)-1]
  357.         self.assertEqual(
  358.             a,
  359.             array.array(self.typecode, self.example[:-1])
  360.         )
  361.  
  362.         a = array.array(self.typecode, self.example)
  363.         del a[-len(self.example)]
  364.         self.assertEqual(
  365.             a,
  366.             array.array(self.typecode, self.example[1:])
  367.         )
  368.  
  369.         self.assertRaises(TypeError, a.__delitem__)
  370.         self.assertRaises(TypeError, a.__delitem__, None)
  371.         self.assertRaises(IndexError, a.__delitem__, len(self.example))
  372.         self.assertRaises(IndexError, a.__delitem__, -len(self.example)-1)
  373.  
  374.     def test_getslice(self):
  375.         a = array.array(self.typecode, self.example)
  376.         self.assertEqual(a[:], a)
  377.  
  378.         self.assertEqual(
  379.             a[1:],
  380.             array.array(self.typecode, self.example[1:])
  381.         )
  382.  
  383.         self.assertEqual(
  384.             a[:1],
  385.             array.array(self.typecode, self.example[:1])
  386.         )
  387.  
  388.         self.assertEqual(
  389.             a[:-1],
  390.             array.array(self.typecode, self.example[:-1])
  391.         )
  392.  
  393.         self.assertEqual(
  394.             a[-1:],
  395.             array.array(self.typecode, self.example[-1:])
  396.         )
  397.  
  398.         self.assertEqual(
  399.             a[-1:-1],
  400.             array.array(self.typecode)
  401.         )
  402.  
  403.         self.assertEqual(
  404.             a[1000:],
  405.             array.array(self.typecode)
  406.         )
  407.         self.assertEqual(a[-1000:], a)
  408.         self.assertEqual(a[:1000], a)
  409.         self.assertEqual(
  410.             a[:-1000],
  411.             array.array(self.typecode)
  412.         )
  413.         self.assertEqual(a[-1000:1000], a)
  414.         self.assertEqual(
  415.             a[2000:1000],
  416.             array.array(self.typecode)
  417.         )
  418.  
  419.     def test_setslice(self):
  420.         a = array.array(self.typecode, self.example)
  421.         a[:1] = a
  422.         self.assertEqual(
  423.             a,
  424.             array.array(self.typecode, self.example + self.example[1:])
  425.         )
  426.  
  427.         a = array.array(self.typecode, self.example)
  428.         a[:-1] = a
  429.         self.assertEqual(
  430.             a,
  431.             array.array(self.typecode, self.example + self.example[-1:])
  432.         )
  433.  
  434.         a = array.array(self.typecode, self.example)
  435.         a[-1:] = a
  436.         self.assertEqual(
  437.             a,
  438.             array.array(self.typecode, self.example[:-1] + self.example)
  439.         )
  440.  
  441.         a = array.array(self.typecode, self.example)
  442.         a[1:] = a
  443.         self.assertEqual(
  444.             a,
  445.             array.array(self.typecode, self.example[:1] + self.example)
  446.         )
  447.  
  448.         a = array.array(self.typecode, self.example)
  449.         a[1:-1] = a
  450.         self.assertEqual(
  451.             a,
  452.             array.array(
  453.                 self.typecode,
  454.                 self.example[:1] + self.example + self.example[-1:]
  455.             )
  456.         )
  457.  
  458.         a = array.array(self.typecode, self.example)
  459.         a[1000:] = a
  460.         self.assertEqual(
  461.             a,
  462.             array.array(self.typecode, 2*self.example)
  463.         )
  464.  
  465.         a = array.array(self.typecode, self.example)
  466.         a[-1000:] = a
  467.         self.assertEqual(
  468.             a,
  469.             array.array(self.typecode, self.example)
  470.         )
  471.  
  472.         a = array.array(self.typecode, self.example)
  473.         a[:1000] = a
  474.         self.assertEqual(
  475.             a,
  476.             array.array(self.typecode, self.example)
  477.         )
  478.  
  479.         a = array.array(self.typecode, self.example)
  480.         a[:-1000] = a
  481.         self.assertEqual(
  482.             a,
  483.             array.array(self.typecode, 2*self.example)
  484.         )
  485.  
  486.         a = array.array(self.typecode, self.example)
  487.         a[1:0] = a
  488.         self.assertEqual(
  489.             a,
  490.             array.array(self.typecode, self.example[:1] + self.example + self.example[1:])
  491.         )
  492.  
  493.         a = array.array(self.typecode, self.example)
  494.         a[2000:1000] = a
  495.         self.assertEqual(
  496.             a,
  497.             array.array(self.typecode, 2*self.example)
  498.         )
  499.  
  500.         a = array.array(self.typecode, self.example)
  501.         self.assertRaises(TypeError, a.__setslice__, 0, 0, None)
  502.         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), None)
  503.  
  504.         b = array.array(self.badtypecode())
  505.         self.assertRaises(TypeError, a.__setslice__, 0, 0, b)
  506.         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), b)
  507.  
  508.     def test_index(self):
  509.         example = 2*self.example
  510.         a = array.array(self.typecode, example)
  511.         self.assertRaises(TypeError, a.index)
  512.         for x in example:
  513.             self.assertEqual(a.index(x), example.index(x))
  514.         self.assertRaises(ValueError, a.index, None)
  515.         self.assertRaises(ValueError, a.index, self.outside)
  516.  
  517.     def test_count(self):
  518.         example = 2*self.example
  519.         a = array.array(self.typecode, example)
  520.         self.assertRaises(TypeError, a.count)
  521.         for x in example:
  522.             self.assertEqual(a.count(x), example.count(x))
  523.         self.assertEqual(a.count(self.outside), 0)
  524.         self.assertEqual(a.count(None), 0)
  525.  
  526.     def test_remove(self):
  527.         for x in self.example:
  528.             example = 2*self.example
  529.             a = array.array(self.typecode, example)
  530.             pos = example.index(x)
  531.             example2 = example[:pos] + example[pos+1:]
  532.             a.remove(x)
  533.             self.assertEqual(a, array.array(self.typecode, example2))
  534.  
  535.         a = array.array(self.typecode, self.example)
  536.         self.assertRaises(ValueError, a.remove, self.outside)
  537.  
  538.         self.assertRaises(ValueError, a.remove, None)
  539.  
  540.     def test_pop(self):
  541.         a = array.array(self.typecode)
  542.         self.assertRaises(IndexError, a.pop)
  543.  
  544.         a = array.array(self.typecode, 2*self.example)
  545.         self.assertRaises(TypeError, a.pop, 42, 42)
  546.         self.assertRaises(TypeError, a.pop, None)
  547.         self.assertRaises(IndexError, a.pop, len(a))
  548.         self.assertRaises(IndexError, a.pop, -len(a)-1)
  549.  
  550.         self.assertEntryEqual(a.pop(0), self.example[0])
  551.         self.assertEqual(
  552.             a,
  553.             array.array(self.typecode, self.example[1:]+self.example)
  554.         )
  555.         self.assertEntryEqual(a.pop(1), self.example[2])
  556.         self.assertEqual(
  557.             a,
  558.             array.array(self.typecode, self.example[1:2]+self.example[3:]+self.example)
  559.         )
  560.         self.assertEntryEqual(a.pop(0), self.example[1])
  561.         self.assertEntryEqual(a.pop(), self.example[-1])
  562.         self.assertEqual(
  563.             a,
  564.             array.array(self.typecode, self.example[3:]+self.example[:-1])
  565.         )
  566.  
  567.     def test_reverse(self):
  568.         a = array.array(self.typecode, self.example)
  569.         self.assertRaises(TypeError, a.reverse, 42)
  570.         a.reverse()
  571.         self.assertEqual(
  572.             a,
  573.             array.array(self.typecode, self.example[::-1])
  574.         )
  575.  
  576.     def test_extend(self):
  577.         a = array.array(self.typecode, self.example)
  578.         self.assertRaises(TypeError, a.extend)
  579.         a.extend(array.array(self.typecode, self.example[::-1]))
  580.         self.assertEqual(
  581.             a,
  582.             array.array(self.typecode, self.example+self.example[::-1])
  583.         )
  584.  
  585.         b = array.array(self.badtypecode())
  586.         self.assertRaises(TypeError, a.extend, b)
  587.  
  588.     def test_coveritertraverse(self):
  589.         try:
  590.             import gc
  591.         except ImportError:
  592.             return
  593.         a = array.array(self.typecode)
  594.         l = [iter(a)]
  595.         l.append(l)
  596.         gc.collect()
  597.  
  598.     def test_buffer(self):
  599.         a = array.array(self.typecode, self.example)
  600.         b = buffer(a)
  601.         self.assertEqual(b[0], a.tostring()[0])
  602.  
  603. class StringTest(BaseTest):
  604.  
  605.     def test_setitem(self):
  606.         super(StringTest, self).test_setitem()
  607.         a = array.array(self.typecode, self.example)
  608.         self.assertRaises(TypeError, a.__setitem__, 0, self.example[:2])
  609.  
  610. class CharacterTest(StringTest):
  611.     typecode = 'c'
  612.     example = '\x01azAZ\x00\xfe'
  613.     smallerexample = '\x01azAY\x00\xfe'
  614.     biggerexample = '\x01azAZ\x00\xff'
  615.     outside = '\x33'
  616.     minitemsize = 1
  617.  
  618.     def test_subbclassing(self):
  619.         class EditableString(array.array):
  620.             def __new__(cls, s, *args, **kwargs):
  621.                 return array.array.__new__(cls, 'c', s)
  622.  
  623.             def __init__(self, s, color='blue'):
  624.                 array.array.__init__(self, 'c', s)
  625.                 self.color = color
  626.  
  627.             def strip(self):
  628.                 self[:] = array.array('c', self.tostring().strip())
  629.  
  630.             def __repr__(self):
  631.                 return 'EditableString(%r)' % self.tostring()
  632.  
  633.         s = EditableString("\ttest\r\n")
  634.         s.strip()
  635.         self.assertEqual(s.tostring(), "test")
  636.  
  637.         self.assertEqual(s.color, "blue")
  638.         s.color = "red"
  639.         self.assertEqual(s.color, "red")
  640.         self.assertEqual(s.__dict__.keys(), ["color"])
  641.  
  642.     def test_nounicode(self):
  643.         a = array.array(self.typecode, self.example)
  644.         self.assertRaises(ValueError, a.fromunicode, unicode(''))
  645.         self.assertRaises(ValueError, a.tounicode)
  646.  
  647. tests.append(CharacterTest)
  648.  
  649. if test_support.have_unicode:
  650.     class UnicodeTest(StringTest):
  651.         typecode = 'u'
  652.         example = unicode(r'\x01\u263a\x00\ufeff', 'unicode-escape')
  653.         smallerexample = unicode(r'\x01\u263a\x00\ufefe', 'unicode-escape')
  654.         biggerexample = unicode(r'\x01\u263a\x01\ufeff', 'unicode-escape')
  655.         outside = unicode('\x33')
  656.         minitemsize = 2
  657.  
  658.         def test_unicode(self):
  659.             self.assertRaises(TypeError, array.array, 'b', unicode('foo', 'ascii'))
  660.  
  661.             a = array.array('u', unicode(r'\xa0\xc2\u1234', 'unicode-escape'))
  662.             a.fromunicode(unicode(' ', 'ascii'))
  663.             a.fromunicode(unicode('', 'ascii'))
  664.             a.fromunicode(unicode('', 'ascii'))
  665.             a.fromunicode(unicode(r'\x11abc\xff\u1234', 'unicode-escape'))
  666.             s = a.tounicode()
  667.             self.assertEqual(
  668.                 s,
  669.                 unicode(r'\xa0\xc2\u1234 \x11abc\xff\u1234', 'unicode-escape')
  670.             )
  671.  
  672.             s = unicode(r'\x00="\'a\\b\x80\xff\u0000\u0001\u1234', 'unicode-escape')
  673.             a = array.array('u', s)
  674.             self.assertEqual(
  675.                 repr(a),
  676.                 r"""array('u', u'\x00="\'a\\b\x80\xff\x00\x01\u1234')"""
  677.             )
  678.  
  679.             self.assertRaises(TypeError, a.fromunicode)
  680.  
  681.     tests.append(UnicodeTest)
  682.  
  683. class NumberTest(BaseTest):
  684.  
  685.     def test_extslice(self):
  686.         a = array.array(self.typecode, range(5))
  687.         self.assertEqual(a[::], a)
  688.         self.assertEqual(a[::2], array.array(self.typecode, [0,2,4]))
  689.         self.assertEqual(a[1::2], array.array(self.typecode, [1,3]))
  690.         self.assertEqual(a[::-1], array.array(self.typecode, [4,3,2,1,0]))
  691.         self.assertEqual(a[::-2], array.array(self.typecode, [4,2,0]))
  692.         self.assertEqual(a[3::-2], array.array(self.typecode, [3,1]))
  693.         self.assertEqual(a[-100:100:], a)
  694.         self.assertEqual(a[100:-100:-1], a[::-1])
  695.         self.assertEqual(a[-100L:100L:2L], array.array(self.typecode, [0,2,4]))
  696.         self.assertEqual(a[1000:2000:2], array.array(self.typecode, []))
  697.         self.assertEqual(a[-1000:-2000:-2], array.array(self.typecode, []))
  698.  
  699.     def test_delslice(self):
  700.         a = array.array(self.typecode, range(5))
  701.         del a[::2]
  702.         self.assertEqual(a, array.array(self.typecode, [1,3]))
  703.         a = array.array(self.typecode, range(5))
  704.         del a[1::2]
  705.         self.assertEqual(a, array.array(self.typecode, [0,2,4]))
  706.         a = array.array(self.typecode, range(5))
  707.         del a[1::-2]
  708.         self.assertEqual(a, array.array(self.typecode, [0,2,3,4]))
  709.         a = array.array(self.typecode, range(10))
  710.         del a[::1000]
  711.         self.assertEqual(a, array.array(self.typecode, [1,2,3,4,5,6,7,8,9]))
  712.  
  713.     def test_assignment(self):
  714.         a = array.array(self.typecode, range(10))
  715.         a[::2] = array.array(self.typecode, [42]*5)
  716.         self.assertEqual(a, array.array(self.typecode, [42, 1, 42, 3, 42, 5, 42, 7, 42, 9]))
  717.         a = array.array(self.typecode, range(10))
  718.         a[::-4] = array.array(self.typecode, [10]*3)
  719.         self.assertEqual(a, array.array(self.typecode, [0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
  720.         a = array.array(self.typecode, range(4))
  721.         a[::-1] = a
  722.         self.assertEqual(a, array.array(self.typecode, [3, 2, 1, 0]))
  723.         a = array.array(self.typecode, range(10))
  724.         b = a[:]
  725.         c = a[:]
  726.         ins = array.array(self.typecode, range(2))
  727.         a[2:3] = ins
  728.         b[slice(2,3)] = ins
  729.         c[2:3:] = ins
  730.  
  731.     def test_iterationcontains(self):
  732.         a = array.array(self.typecode, range(10))
  733.         self.assertEqual(list(a), range(10))
  734.         b = array.array(self.typecode, [20])
  735.         self.assertEqual(a[-1] in a, True)
  736.         self.assertEqual(b[0] not in a, True)
  737.  
  738.     def check_overflow(self, lower, upper):
  739.         # method to be used by subclasses
  740.  
  741.         # should not overflow assigning lower limit
  742.         a = array.array(self.typecode, [lower])
  743.         a[0] = lower
  744.         # should overflow assigning less than lower limit
  745.         self.assertRaises(OverflowError, array.array, self.typecode, [lower-1])
  746.         self.assertRaises(OverflowError, a.__setitem__, 0, lower-1)
  747.         # should not overflow assigning upper limit
  748.         a = array.array(self.typecode, [upper])
  749.         a[0] = upper
  750.         # should overflow assigning more than upper limit
  751.         self.assertRaises(OverflowError, array.array, self.typecode, [upper+1])
  752.         self.assertRaises(OverflowError, a.__setitem__, 0, upper+1)
  753.  
  754.     def test_subclassing(self):
  755.         typecode = self.typecode
  756.         class ExaggeratingArray(array.array):
  757.             __slots__ = ['offset']
  758.  
  759.             def __new__(cls, typecode, data, offset):
  760.                 return array.array.__new__(cls, typecode, data)
  761.  
  762.             def __init__(self, typecode, data, offset):
  763.                 self.offset = offset
  764.  
  765.             def __getitem__(self, i):
  766.                 return array.array.__getitem__(self, i) + self.offset
  767.  
  768.         a = ExaggeratingArray(self.typecode, [3, 6, 7, 11], 4)
  769.         self.assertEntryEqual(a[0], 7)
  770.  
  771.         self.assertRaises(AttributeError, setattr, a, "color", "blue")
  772.  
  773. class SignedNumberTest(NumberTest):
  774.     example = [-1, 0, 1, 42, 0x7f]
  775.     smallerexample = [-1, 0, 1, 42, 0x7e]
  776.     biggerexample = [-1, 0, 1, 43, 0x7f]
  777.     outside = 23
  778.  
  779.     def test_overflow(self):
  780.         a = array.array(self.typecode)
  781.         lower = -1 * long(pow(2, a.itemsize * 8 - 1))
  782.         upper = long(pow(2, a.itemsize * 8 - 1)) - 1L
  783.         self.check_overflow(lower, upper)
  784.  
  785. class UnsignedNumberTest(NumberTest):
  786.     example = [0, 1, 17, 23, 42, 0xff]
  787.     smallerexample = [0, 1, 17, 23, 42, 0xfe]
  788.     biggerexample = [0, 1, 17, 23, 43, 0xff]
  789.     outside = 0xaa
  790.  
  791.     def test_overflow(self):
  792.         a = array.array(self.typecode)
  793.         lower = 0
  794.         upper = long(pow(2, a.itemsize * 8)) - 1L
  795.         self.check_overflow(lower, upper)
  796.  
  797.  
  798. class ByteTest(SignedNumberTest):
  799.     typecode = 'b'
  800.     minitemsize = 1
  801. tests.append(ByteTest)
  802.  
  803. class UnsignedByteTest(UnsignedNumberTest):
  804.     typecode = 'B'
  805.     minitemsize = 1
  806. tests.append(UnsignedByteTest)
  807.  
  808. class ShortTest(SignedNumberTest):
  809.     typecode = 'h'
  810.     minitemsize = 2
  811. tests.append(ShortTest)
  812.  
  813. class UnsignedShortTest(UnsignedNumberTest):
  814.     typecode = 'H'
  815.     minitemsize = 2
  816. tests.append(UnsignedShortTest)
  817.  
  818. class IntTest(SignedNumberTest):
  819.     typecode = 'i'
  820.     minitemsize = 2
  821. tests.append(IntTest)
  822.  
  823. class UnsignedIntTest(UnsignedNumberTest):
  824.     typecode = 'I'
  825.     minitemsize = 2
  826. tests.append(UnsignedIntTest)
  827.  
  828. class LongTest(SignedNumberTest):
  829.     typecode = 'l'
  830.     minitemsize = 4
  831. tests.append(LongTest)
  832.  
  833. class UnsignedLongTest(UnsignedNumberTest):
  834.     typecode = 'L'
  835.     minitemsize = 4
  836. tests.append(UnsignedLongTest)
  837.  
  838. class FPTest(NumberTest):
  839.     example = [-42.0, 0, 42, 1e5, -1e10]
  840.     smallerexample = [-42.0, 0, 42, 1e5, -2e10]
  841.     biggerexample = [-42.0, 0, 42, 1e5, 1e10]
  842.     outside = 23
  843.  
  844.     def assertEntryEqual(self, entry1, entry2):
  845.         self.assertAlmostEqual(entry1, entry2)
  846.  
  847.     def test_byteswap(self):
  848.         a = array.array(self.typecode, self.example)
  849.         self.assertRaises(TypeError, a.byteswap, 42)
  850.         if a.itemsize in (1, 2, 4, 8):
  851.             b = array.array(self.typecode, self.example)
  852.             b.byteswap()
  853.             if a.itemsize==1:
  854.                 self.assertEqual(a, b)
  855.             else:
  856.                 # On alphas treating the byte swapped bit patters as
  857.                 # floats/doubles results in floating point exceptions
  858.                 # => compare the 8bit string values instead
  859.                 self.assertNotEqual(a.tostring(), b.tostring())
  860.             b.byteswap()
  861.             self.assertEqual(a, b)
  862.  
  863. class FloatTest(FPTest):
  864.     typecode = 'f'
  865.     minitemsize = 4
  866. tests.append(FloatTest)
  867.  
  868. class DoubleTest(FPTest):
  869.     typecode = 'd'
  870.     minitemsize = 8
  871. tests.append(DoubleTest)
  872.  
  873. def test_main():
  874.     test_support.run_unittest(*tests)
  875.  
  876. if __name__=="__main__":
  877.     test_main()
  878.